home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / macros / lamstex / index / index.c < prev    next >
C/C++ Source or Header  |  1991-09-06  |  60KB  |  2,690 lines
  1. /************************************************************************/
  2. /*   File:    Index.c                                */
  3. /************************************************************************/
  4. /*   Developer:    TeXplorators Inc., Houston, Texas                */
  5. /*   PRODUCT  :    Index: Sort TeX index entries alphabetically        */
  6. /*   Module   :    index                            */
  7. /*   Notes    :    This source code is compiled with Microsoft C 5.1       */
  8. /************************************************************************/
  9. /*
  10.             SOFTWARE LICENSE AGREEMENT
  11.  
  12. 1. PURPOSE
  13.     This agreement recites the terms and conditions under which 
  14. The TeXplorators Corporation ("TEXPLORATORS") agrees to grant you a 
  15. free, nonexclusive, transferable license to use the INDEX software.
  16.  
  17. 2. UNDERTAKINGS BY TEXPLORATORS
  18.     2A. Ownership: Ownership of the INDEX software remains 
  19. exclusively in TEXPLORATORS.
  20.     2B. License Fee: TEXPLORATORS makes the INDEX software 
  21. available to you free of any license fee.
  22.     2C. Disclaimers: TEXPLORATORS DISCLAIMS ALL EXPRESS OR IMPLIED
  23. WARRANTIES OF INDEX'S MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR
  24. PURPOSE.
  25.     2D. Liability: TEXPLORATORS' LIABILITY, IF ANY, IS LIMITED TO 
  26. THE DISTRIBUTION FEE YOU PAID, AND DOES NOT INCLUDE SPECIAL AND/OR
  27. CONSEQUENTIAL DAMAGES ARISING OUT OF, OR IN CONNECTION WITH, THE USE 
  28. OF INDEX.  SINCE SOME STATES DISALLOW LIMITATION OR EXCLUSION OF 
  29. LIABILITY, THIS LIMITATION OR EXCLUSION MAY NOT APPLY TO YOU.
  30.  
  31. 3. UNDERTAKINGS BY YOU.
  32.     3A. Proper Use: You agree to use the INDEX software in
  33. compliance with the terms and conditions hereof.
  34.     3B. Notices on Authorized Copies: You agree to take reasonable
  35. precautions to preserve the propriety of the INDEX software by
  36. duplicating verbatim, on all copies thereof, the notices of TEXPLORATORS'
  37. interests recited thereon.  You agree to note that source code is 
  38. available upon request, if you do not distribute source code with the
  39. INDEX software.
  40.     3C. Distribution: You are encouraged to freely distribute the
  41. INDEX software, including source code, on or through any common media
  42. including diskettes and electronic bulletin board systems.  You agree to
  43. distribute this license with each and every copy so distributed, and to 
  44. either distribute source code therewith or make source code available upon
  45. request. You may charge a distribution fee to cover the cost of diskettes,
  46. handling and shipping.
  47.     3D. Modifications: You are authorized to make modifications to
  48. INDEX, but these modifications must be conspicuously noted and dated
  49. therewith.
  50.     3E. License Fee: You may not charge a license fee for the
  51. INDEX software, either in its original or modified form.  However, you
  52. may charge a license fee for your software which is broader in scope
  53. than INDEX, whereby INDEX is not a primary functional unit thereof.
  54.  
  55. 4. SCOPE
  56.     This Software License Agreement constitutes the entire agreement
  57. between TEXPLORATORS and you regarding the INDEX software, and shall
  58. be construed under the laws of the State of TEXAS.
  59.  
  60.                     The TeXplorators Corporation
  61.                     By: Michael Spivak, President
  62.  
  63. Page*/
  64. /*
  65.   HISTORY:
  66.    [03/07/1991] - Index now operates on a single .ndx file - there will be
  67.                   .npg file. An error message will be issued if a
  68.                   \Page{...}{...}{...} does not follow each entry.
  69.                   Each entry buffer size is expanded to 300 symbols.
  70. */
  71.  
  72. /* Configuration and defines for Unix 05/08/1991, P. A. MacKay */
  73.  
  74. /* System-dependent defines */
  75. #include "config.h"
  76.  
  77. /*------------------------------*/
  78. /*    includes        */
  79. /*------------------------------*/
  80. #include  <stdio.h>
  81. #include  <ctype.h>
  82. #include  <malloc.h>    
  83. #include  <string.h>
  84. #ifdef ANSI
  85. #include  <stdlib.h>
  86. #endif
  87. #include  <memory.h>
  88.  
  89. /*------------------------------*/
  90. /*    defines            */
  91. /*------------------------------*/
  92.  
  93. #define TRUE        1
  94. #define FALSE       0
  95.  
  96. #define MAX_STRING    5120
  97. #define MAX_ENTRIES   15000
  98. #define MAX_DEFINES   200
  99. #define MAX_ABBREVS   200
  100. #define MAX_PAGEORDER 200
  101. #define MAX_PAGEENTRY 500
  102.  
  103. #define SPACE       32
  104. #define COMMA       ','
  105. #define STAR        '*'
  106. #define DQUOTE      34
  107. #define BAR         '|'
  108. #define LBRACE      123
  109. #define RBRACE      125
  110. #define RSLASH        '\\'
  111. #define MINUS       '-'
  112. #define PLUS        '+'
  113. #define NL        '\n'
  114. #define LBRACKET    '['
  115. #define RBRACKET    ']'
  116. #define LPAREN      '('
  117. #define RPAREN      ')'
  118. #define QUOTE       39
  119. #define DOLLAR      '$'
  120. #define ATSIGN      '@'
  121. #define TILDE       '~'
  122. #define EXCLAIM     '!'
  123. #define CARET       '^'
  124. #define USCORE      '_'
  125. #define EQUAL       '='
  126. #define COLON       ':'
  127. #define SEMI        ';'
  128. #define LQUOTE      '`'
  129. #define GREATER     '>'
  130. #define LESS        '<'
  131. #define QUESTION    '?'
  132. #define SLASH       '/'
  133. #define PERIOD      '.'
  134.  
  135. #define ZERO        '0'
  136. #define ONE         '1'
  137. #define TWO        '2'
  138. #define THREE       '3'
  139. #define FOUR        '4'
  140. #define FIVE        '5'
  141.  
  142. #define ENTRY1       1
  143. #define ENTRY2       4
  144. #define ENTRY3       7
  145. #define ENTRY4      10
  146. #define ENTRY5      13
  147.  
  148. #define PRE_TYPE     0
  149. #define POST_TYPE    1
  150. #define ALIAS_TYPE   2
  151. #define ENTRY_TYPE   3
  152. #define XREF_TYPE    4
  153. #define CROSS_TYPE   5
  154. #define OTHER_TYPE   6
  155.  
  156. #define LEVEL0        0
  157. #define LEVEL1        1
  158. #define LEVEL2        2
  159. #define LEVEL3        3
  160. #define LEVEL4        4
  161. #define LEVEL5        5
  162.  
  163. #define E1            1
  164. #define E1_PRE        2
  165. #define E1_POST       3
  166. #define E1_ALIAS     23
  167. #define E1_CS        28
  168.  
  169. #define E2            4
  170. #define E2_PRE        5
  171. #define E2_POST       6
  172. #define E2_ALIAS     24
  173. #define E2_CS        29
  174.  
  175. #define E3            7
  176. #define E3_PRE        8
  177. #define E3_POST       9
  178. #define E3_ALIAS     25
  179. #define E3_CS        30
  180.  
  181. #define E4           10
  182. #define E4_PRE       11
  183. #define E4_POST      12
  184. #define E4_ALIAS     26
  185. #define E4_CS        31
  186.  
  187. #define E5           13
  188. #define E5_PRE       14
  189. #define E5_POST      15
  190. #define E5_ALIAS     27
  191. #define E5_CS        32
  192.  
  193. #define XREF         16
  194. #define NUMBER       17
  195. #define CSNAME       18
  196. #define PREFIX       19
  197. #define POSTFIX      20
  198. #define PAGE_SPAN    21
  199. #define LARGEST      22
  200. #define CTRLSEQ      33
  201. #define CROSS_REF    34
  202.  
  203. /*------------------------------*/
  204. /*    typedefs        */
  205. /*------------------------------*/
  206. #ifdef MICROSOFT_C
  207. typedef unsigned int   WORD;
  208. #else
  209. typedef unsigned short   WORD;
  210. #endif
  211. typedef unsigned char  BYTE;
  212.  
  213. typedef struct
  214. {
  215.   char *fields[35];
  216. } FieldType;
  217.  
  218. typedef struct
  219. {
  220.   FieldType *item;
  221. } EntryType;
  222.  
  223. typedef struct
  224. {
  225.   char *astr;
  226.   char *xstr;
  227. } AbbrvType;
  228.  
  229. typedef struct
  230. {
  231.   char *style;
  232.   char *pre;
  233.   char *post;
  234.   BYTE order;
  235.   BYTE nstyle;
  236.   BYTE npre;
  237.   BYTE npost;
  238. } PageOrderType;
  239.  
  240. /*------------------------------*/
  241. /*    data structures        */
  242. /*------------------------------*/
  243. EntryType Entry[MAX_ENTRIES];    /* entries            */
  244. char      *define[MAX_DEFINES];    /* defines            */
  245. AbbrvType *abbrev[MAX_ABBREVS];    /* abbrevs            */
  246. PageOrderType *PO[MAX_PAGEORDER];/*page orders            */
  247. int       SubPageOrder[MAX_PAGEENTRY];
  248. int       SortingOrder[35];     /* sorting order indices    */
  249. int       FirstOrder;        /* First Sorting Order entry*/
  250. int       LastOrder;        /* Last Sorting Order entry */
  251. int       PageOrder[10];        /* Page order indices       */
  252. int       PageOrderFirst;    /* Fist page order entry    */
  253. int       PageOrderLast;    /* Last page order entry    */
  254. char      PageType;        
  255. int       PageIndex;
  256. int       PageSpan;
  257. int       Tindex;        /* Topage Index         */
  258. char      string[300];        /* working string buffer    */
  259. FILE      *ndxfile;        /* index file            */
  260. FILE      *xdxfile;        /* sorted file            */
  261. FILE      *xxxfile;        /* temporary file        */
  262. char      ndxname[80];        /* .ndx file name        */
  263. char      xdxname[80];        /* .xdx file name        */
  264. char      tmpname[80];        /* .@d@ file name        */
  265. char      idxname[80];        /* .idx file name        */
  266. BYTE      alias;        /* alias flag            */
  267. BYTE      xref;            /* xref flag            */
  268. BYTE      crossref;        /* crossref flag            */
  269. BYTE      curEntry;        /* type of entry appears    */
  270. WORD      nitems;        /* number of input lines    */
  271. WORD      ndef;         /* number of defs        */
  272. WORD      nabb;            /* number of abbrevs        */
  273. WORD      npo;            /* number of pageorders        */
  274. char      curLetter;        /* current letter        */
  275. char      preLetter;        /* previous letter        */
  276. BYTE      FirstEntry;        /* first entry flag        */
  277. char      pagenum[80];        /* page number            */
  278. char      prevnum[80];        /* previous page number        */
  279. BYTE      skippage;        /* skip page flag        */
  280. char      *nullstr="";        /* NULL string            */
  281. char      *NULLPTR;        /* NULL pointer            */
  282. char      *delstr="D";        /* Delete string        */
  283. char      *DELPTR;        /* DEL pointer            */
  284. BYTE      idxfile;              /* make idxfile            */
  285. char      msgbuf[1024];         /* message buffer        */
  286. int       curIndex;        /* current index        */
  287. char      arg1[300], arg2[300], arg3[300], arg4[300], arg5[300];
  288.  
  289. /*------------------------------*/
  290. /*    functions prototypes    */
  291. /*------------------------------*/
  292. #ifdef ANSI /* Use ANSI C prototypes */
  293. void  beep(void);
  294. void  BuildProc(void);
  295. void  BuildString(int);
  296.  
  297. char *CheckAbbrev(char s[], char *q);
  298. void  CheckAlias(int);
  299. BYTE  CheckLevel(int cur, int idx, BYTE level);
  300. int   CompareStrings(int i,int j);
  301. int   CompareStringsPO(int i,int j);
  302. void  copyString(int,int,char *);
  303.  
  304. void  doNDX(int,char *);
  305. void  doNPG(int,char *);
  306. void  DoNormal(int idx,char arg[]);
  307. void  DoVariant(int idx, char arg[]);
  308. int   DupPageFormat(int idx, char arg[]);
  309. int   DupEntry(int idx, int cur);
  310. int   DupXref(int idx, int cur);
  311.  
  312. void  error(char *);
  313. void  exit(int);
  314.  
  315. int   FindLastT( int idx );
  316. void  FreeEntry( int idx );
  317. void  FreeMem(void);
  318.  
  319. void  GetAbbrevSpace(int);
  320. void  GetArg(int idx,char arg[],BYTE pre,BYTE cs,BYTE entry,
  321.              BYTE post,BYTE alias);
  322. void  GetArgs(int idx,char *arg1,char *arg2,char *arg3,
  323.               char *arg4,char *arg5);
  324. BYTE  GetD2(int cur,int idx);
  325. void  GetFieldSpace(int);
  326. BYTE  GetPageNum(int idx);
  327. int   GetPageOrder(int);
  328. void  GetPageOrderSpace(int);
  329. char *GetStringSpace(char *);
  330. int   GetSubLevel(int, int);
  331.  
  332. void  InitProc(void);
  333.  
  334. void  OutputProc(int idx,char *arg1,char *arg2,char *arg3,
  335.                  char *arg4,char *arg5);
  336.  
  337. int  main(int argc, char *argv[]);
  338. void  MoveEntry( int from, int to );
  339.  
  340. void  PreProc(void);
  341. void  printMSG(char *);
  342. void  PrintErrorMSG(void);
  343. void  PutPageNum(int idx);
  344. void  PutByte( char c, FILE *f );
  345. void  PutString( char string[], FILE *f );
  346.  
  347. void  ReduceSpaces(char *);
  348. void  RemoveDuplicates( void );
  349. void  RemoveEmptySet(char *str);
  350. void  RemoveSpaces(char *);
  351. void  RemoveTrailingSpace(char *str);
  352.  
  353. void  ScanEntry( char line[] );
  354. char *SkipSpaces(char *p);
  355. void  SkipSpacesReverse(int len, char *p);
  356. void  SortPageNumber( int beg, int end );
  357. void  SortProc(void);
  358. void  strCopy(char *,char *,int);
  359. void  SwapStrings(int cur, int nxt);
  360. void  syntax_error(char *);
  361.  
  362. void  TeXOut(void);
  363. void  TeXPut(int idx);
  364.  
  365. void  xref_proc(int idx);
  366. void  xxref_proc(int idx);
  367. void  other_proc(int idx);
  368. #else
  369. /* Use old-style K&R function declarations */
  370. void  beep();
  371. void  BuildProc();
  372. void  BuildString();
  373.  
  374. char *CheckAbbrev();
  375. void  CheckAlias();
  376. BYTE  CheckLevel();
  377. int   CompareStrings();
  378. int   CompareStringsPO();
  379. void  copyString();
  380.  
  381. void  doNDX();
  382. void  doNPG();
  383. void  DoNormal();
  384. void  DoVariant();
  385. int   DupPageFormat();
  386. int   DupEntry();
  387. int   DupXref();
  388.  
  389. void  error();
  390. void  exit();
  391.  
  392. int   FindLastT();
  393. void  FreeEntry();
  394. void  FreeMem();
  395.  
  396. void  GetAbbrevSpace();
  397. void  GetArg();
  398. void  GetArgs();
  399. BYTE  GetD2();
  400. void  GetFieldSpace();
  401. BYTE  GetPageNum();
  402. int   GetPageOrder();
  403. void  GetPageOrderSpace();
  404. char *GetStringSpace();
  405. int   GetSubLevel();
  406.  
  407. void  InitProc();
  408.  
  409. void  OutputProc();
  410.  
  411. int main();
  412. void  MoveEntry();
  413.  
  414. void  PreProc();
  415. void  printMSG();
  416. void  PrintErrorMSG();
  417. void  PutPageNum();
  418. void  PutByte();
  419. void  PutString();
  420.  
  421. void  ReduceSpaces();
  422. void  RemoveDuplicates();
  423. void  RemoveEmptySet();
  424. void  RemoveSpaces();
  425. void  RemoveTrailingSpace();
  426.  
  427. void  ScanEntry();
  428. char *SkipSpaces();
  429. void  SkipSpacesReverse();
  430. void  SortPageNumber();
  431. void  SortProc();
  432. void  strCopy();
  433. void  SwapStrings();
  434. void  syntax_error();
  435.  
  436. void  TeXOut();
  437. void  TeXPut();
  438.  
  439. void  xref_proc();
  440. void  xxref_proc();
  441. void  other_proc();
  442. #endif
  443.  
  444. /*------------------------------*/
  445. /*    functions         */
  446. /*------------------------------*/
  447.  
  448. void beep()
  449. {
  450.    printf("\007\b");
  451.    return;
  452. }
  453.  
  454. void FreeMem()
  455. {
  456. int i,j;
  457.    for (i=0; i<=nitems; i++)
  458.    {
  459.      if ( Entry[i].item!=NULL )
  460.      {
  461.        for (j=E1; j<=CROSS_REF; j++)
  462.        {
  463.     if (Entry[i].item->fields[j]!=NULLPTR )
  464.         free( Entry[i].item->fields[j] );
  465.        }
  466.      }
  467.    }
  468.    for (i=0; i<MAX_DEFINES; i++)
  469.     if ( define[i]!=NULL )
  470.          free( define[i] );
  471.    for (i=0; i<MAX_ABBREVS; i++)
  472.     if ( abbrev[i]!=NULL )
  473.     {
  474.          if ( abbrev[i]->astr != NULL ) free( abbrev[i]->astr );
  475.          if ( abbrev[i]->xstr != NULL ) free( abbrev[i]->xstr );
  476.          free( abbrev[i] );
  477.     }
  478.     
  479.    for (i=0; i<MAX_PAGEORDER; i++)
  480.     if ( PO[i]!=NULL )
  481.     {
  482.          if ( PO[i]->style !=NULL ) free( PO[i]->style );
  483.          if ( PO[i]->pre   !=NULL ) free( PO[i]->pre );
  484.          if ( PO[i]->post  !=NULL ) free( PO[i]->post );
  485.          free( PO[i] );
  486.         }
  487.  
  488.    return;
  489. }
  490.  
  491. void error(s)
  492. char *s;
  493. {
  494.    beep();    
  495.    printf("\n%s\n",s);
  496.    FreeMem();
  497.    exit(0);
  498. }
  499.  
  500. void syntax_error(s)
  501. char *s;
  502. { 
  503.   sprintf(string,"syntax error! -> %s",s);
  504.   error(string); 
  505. }
  506.  
  507.  
  508. void printMSG(s)
  509. char *s;
  510. {
  511.    int i;
  512.    printf("\r");
  513.    for (i=0; i<78; i++)
  514.        printf(" ");
  515.    printf("\r");
  516.    printf("%s",s);
  517.    return;
  518. }
  519.  
  520.  
  521. void PutByte(c,f)
  522.  char c; 
  523.  FILE *f;
  524. {
  525.   fputc( c, f );
  526.   if ( ferror(f) )
  527.        error("! File write error - out of disk space");
  528. } /* end - PutByte */
  529.  
  530.  
  531. void PutString(s,f)
  532.  char *s; 
  533.  FILE *f;
  534. {
  535.    fputs( s, f );
  536.    if ( ferror(f) )
  537.        error("! File write error - out of disk space");
  538. } /* end  - PutString */
  539.  
  540. /* Get Field Space */
  541. void GetFieldSpace(idx)
  542. int  idx;
  543. {
  544. int  i;
  545.    
  546.    /* Check for boundary conditions */
  547.    if ( idx >= MAX_ENTRIES )
  548.    {
  549.       sprintf(string,"! number of entries (%d) exceeded MAXIMUM allowed (%d)",
  550.           idx,MAX_ENTRIES);
  551.       error( string );
  552.    }
  553.    
  554.    Entry[idx].item = (FieldType *) malloc( sizeof(FieldType) );
  555.    if ( Entry[idx].item==NULL )
  556.     error("! out of fields space");
  557.    for (i=0; i<35; i++)
  558.     Entry[idx].item->fields[i]=NULLPTR;
  559.    return;
  560. }
  561.  
  562.  
  563. /* Get Abbrev Space */
  564. void GetAbbrevSpace(idx)
  565. int  idx;
  566. {
  567.    /* Check for boundary conditions */
  568.    if ( idx >= MAX_ABBREVS )
  569.    {
  570.       sprintf(string,"! number of abbrevs (%d) exceeded MAXIMUM allowed (%d)",
  571.           idx,MAX_ABBREVS);
  572.       error( string );
  573.    }
  574.    
  575.    abbrev[idx] = (AbbrvType *) malloc( sizeof(AbbrvType) );
  576.    if ( abbrev[idx]==NULL )
  577.     error("! out of space");
  578.    abbrev[idx]->astr = NULL;
  579.    abbrev[idx]->xstr = NULL;
  580.    return;
  581. }
  582.  
  583. /* Get PageOrder Space */
  584. void GetPageOrderSpace(idx)
  585. int  idx;
  586. {
  587.  
  588.    /* Check for boundary conditions */
  589.    if ( idx >= MAX_PAGEORDER )
  590.    {
  591.       sprintf(string,
  592.       "! number of pageorders directives (%d) exceeded MAXIMUM allowed (%d)",
  593.           idx,MAX_PAGEORDER);
  594.       error( string );
  595.    }
  596.   
  597.    PO[idx] = (PageOrderType *) malloc( sizeof(PageOrderType) );
  598.    if ( PO[idx]==NULL )
  599.     error("! out of space");
  600.    PO[idx]->style = NULL;
  601.    PO[idx]->pre   = NULL;
  602.    PO[idx]->post  = NULL;
  603.    PO[idx]->order    = 0;
  604.    PO[idx]->nstyle   = 0;
  605.    PO[idx]->npre     = 0;
  606.    PO[idx]->npost    = 0;
  607.    return;
  608. }
  609.  
  610.  
  611. /* Get String Space */
  612. char * GetStringSpace(str)
  613. char *str;
  614. {
  615. char *p;
  616. int  i;
  617.    i = strlen(str);
  618.    p = (char *) malloc( i+1 );
  619.    if ( p==NULL )
  620.     error("! out of strings space");
  621.    return(p);
  622. }
  623.  
  624.  
  625. void InitProc()
  626. {
  627.   int i;
  628.   for (i=0; i<MAX_ENTRIES; i++)
  629.        Entry[i].item = NULL;
  630.   for (i=0; i<MAX_DEFINES; i++)
  631.        define[i] = NULL;
  632.   for (i=0; i<MAX_ABBREVS; i++)
  633.        abbrev[i] = NULL;
  634.   for (i=0; i<MAX_PAGEORDER; i++)
  635.        PO[i] = NULL;
  636.   FirstEntry = TRUE;    
  637.   NULLPTR    = &nullstr[0];
  638.   PageType   = 0;
  639.   PageIndex  = 0;
  640.   PageSpan   = FALSE;
  641.   Tindex     = 0;
  642.   
  643.   SortingOrder[1] =E1;
  644.   SortingOrder[2] =E1_ALIAS;
  645.   SortingOrder[3] =E1_PRE;
  646.   SortingOrder[4] =E1_POST;
  647.   
  648.   SortingOrder[5] =E2;
  649.   SortingOrder[6] =E2_ALIAS;
  650.   SortingOrder[7] =E2_PRE;
  651.   SortingOrder[8] =E2_POST;
  652.   
  653.   SortingOrder[9] =E3;
  654.   SortingOrder[10]=E3_ALIAS; 
  655.   SortingOrder[11]=E3_PRE;
  656.   SortingOrder[12]=E3_POST;
  657.   
  658.   SortingOrder[13]=E4;  
  659.   SortingOrder[14]=E4_ALIAS;
  660.   SortingOrder[15]=E4_PRE;
  661.   SortingOrder[16]=E4_POST;
  662.   
  663.   SortingOrder[17]=E5;
  664.   SortingOrder[18]=E5_ALIAS;  
  665.   SortingOrder[19]=E5_PRE;  
  666.   SortingOrder[20]=E5_POST;
  667.   SortingOrder[21]=CROSS_REF;
  668.  
  669.   FirstOrder = 1;
  670.   LastOrder  = 21;
  671.  
  672.   PageOrder[0] = CSNAME;
  673.   PageOrder[1] = PREFIX;
  674.   PageOrder[2] = NUMBER;
  675.   PageOrder[3] = POSTFIX;
  676.  
  677.   PageOrderFirst = 0;
  678.   PageOrderLast  = 3;
  679.   
  680.   return;
  681. }
  682.  
  683. void ReduceSpaces(str)
  684. char *str;
  685. {
  686.    char *p;
  687.    char *q;
  688.  
  689.    p = str; q = str;
  690.    while ( *p != 0 )
  691.    {
  692.       if ( (*p == SPACE) && (*(p+1) == SPACE) ) p++;
  693.       else
  694.           *q++ = *p++;
  695.    }
  696.    *q = *p;
  697.    return;
  698. }
  699.  
  700.  
  701. void BuildString(idx)
  702. int idx;
  703. {
  704.   int  i;
  705.   char cbuf[300];
  706.   char str[300];
  707.  
  708.   string[0] = 0;
  709.   for (i=E1; i<NUMBER; i++)
  710.   {
  711.     switch( i )
  712.     {
  713.       case 2: case 5: case 8: case 11: case 14:
  714.       case 3: case 6: case 9: case 12: case 15:    
  715.        if ( Entry[idx].item->fields[i]!=NULLPTR )
  716.        {
  717.                 memcpy(cbuf,Entry[idx].item->fields[i],
  718.                    strlen(Entry[idx].item->fields[i])+1);
  719.        }
  720.        else cbuf[0]=0;
  721.        sprintf(str,"%s %c",cbuf,BAR);
  722.        strcat(string,str);
  723.        break;
  724.       default:
  725.        if ( Entry[idx].item->fields[i]!=NULLPTR )
  726.                 memcpy(cbuf,Entry[idx].item->fields[i],
  727.                strlen(Entry[idx].item->fields[i])+1);
  728.        else cbuf[0] = 0;
  729.        sprintf(str,"%s %c",cbuf,BAR);
  730.        ReduceSpaces(&str[0]);    
  731.        strcat(string,str);
  732.        break;
  733.       }
  734.   }
  735.   
  736.   for (i=NUMBER; i<=CROSS_REF; i++)
  737.   {
  738.     if ( Entry[idx].item->fields[i]!=NULLPTR )
  739.          memcpy(cbuf,Entry[idx].item->fields[i], 
  740.             strlen(Entry[idx].item->fields[i])+1);
  741.     else cbuf[0]=0;
  742.     sprintf(str,"%s%c",cbuf,BAR);
  743.     ReduceSpaces(&str[0]);    
  744.     strcat(string,str);
  745.   }
  746.  
  747.   return;
  748. }
  749.  
  750. int GetSubLevel(n,op)
  751. int n,op;
  752. {
  753. int  cur;    
  754.    switch ( op )
  755.    {
  756.      case 'a':   cur = 22 + n; curEntry = ALIAS_TYPE; alias = TRUE; 
  757.           break;
  758.      case MINUS: cur = n*3 -1; curEntry = PRE_TYPE; 
  759.           break;
  760.      case PLUS:  cur = n*3;    curEntry = POST_TYPE; 
  761.           break;
  762.      case 'e':   cur = 27 + n; curEntry = ENTRY_TYPE; 
  763.           break;
  764.      default:    cur = 0; 
  765.           break;
  766.    }
  767.   return(cur);
  768. }
  769.  
  770. void CheckAlias(idx)
  771. int idx;
  772. {
  773. char *p;
  774.  
  775.    if ( Entry[idx].item->fields[E1_ALIAS]!=NULLPTR )
  776.    {
  777.        p = Entry[idx].item->fields[E1];
  778.        Entry[idx].item->fields[E1] = Entry[idx].item->fields[E1_ALIAS];
  779.        Entry[idx].item->fields[E1_ALIAS] = p;
  780.    }
  781.  
  782.    if ( Entry[idx].item->fields[E2_ALIAS]!=NULLPTR )
  783.    {
  784.        p = Entry[idx].item->fields[E2];
  785.        Entry[idx].item->fields[E2] = Entry[idx].item->fields[E2_ALIAS];
  786.        Entry[idx].item->fields[E2_ALIAS] = p;
  787.    }
  788.  
  789.    if ( Entry[idx].item->fields[E3_ALIAS]!=NULLPTR )
  790.    {
  791.        p = Entry[idx].item->fields[E3];
  792.        Entry[idx].item->fields[E3] = Entry[idx].item->fields[E3_ALIAS];
  793.        Entry[idx].item->fields[E3_ALIAS] = p;
  794.    }
  795.  
  796.    if ( Entry[idx].item->fields[E4_ALIAS]!=NULLPTR )
  797.    {
  798.        p = Entry[idx].item->fields[E4];
  799.        Entry[idx].item->fields[E4] = Entry[idx].item->fields[E4_ALIAS];
  800.        Entry[idx].item->fields[E4_ALIAS] = p;
  801.    }
  802.  
  803.    if ( Entry[idx].item->fields[E5_ALIAS]!=NULLPTR )
  804.    {
  805.        p = Entry[idx].item->fields[E5];
  806.        Entry[idx].item->fields[E5] = Entry[idx].item->fields[E5_ALIAS];
  807.        Entry[idx].item->fields[E5_ALIAS] = p;
  808.    }
  809.    return;    
  810. }
  811.  
  812.  
  813. void strCopy(d,s,len)
  814. char *d, *s;
  815. int  len;
  816. {
  817. int  i;
  818.    for (i=0; i<=len; i++)
  819.         *(d+i) = *(s+i);
  820.    return;    
  821. }
  822.  
  823. void copyString(idx,cur,str)
  824. int  idx,cur;
  825. char *str;
  826. {
  827.  if ( cur == 0 ) return;    
  828.     Entry[idx].item->fields[cur] = GetStringSpace( str );
  829.     strcpy(Entry[idx].item->fields[cur], str );
  830.     return;    
  831. }
  832.  
  833. char *SkipSpaces(p)
  834. char *p;
  835. {
  836.    while ( *p==SPACE && *p!=0 ) p++;    
  837.    return(p);    
  838. }
  839.  
  840. void SkipSpacesReverse(len,q)
  841. int  len;
  842. char *q;
  843. {
  844.    char *r;
  845.  
  846.    r = q-2;
  847.    while ( *r==SPACE && len>0 ) 
  848.    { r--; len--; }
  849.    r++; *r = 0;
  850.    
  851.    return;    
  852. }
  853.  
  854. void RemoveSpaces(str)
  855. char *str;
  856. {
  857.    char *p;
  858.    char *q;
  859.  
  860.    p = q = str; 
  861.    while ( *p != 0 )
  862.    {
  863.       if ( (*p == SPACE) ) p++;
  864.       else
  865.           *q++ = *p++;
  866.    }
  867.    *q = *p;
  868.    return;
  869. }
  870.  
  871. void RemoveEmptySet(str)
  872. char *str;
  873. {
  874.    char *p;
  875.    char *q;   
  876.  
  877.    if ( strlen(str) <= 2 ) return;
  878.    p = str; q = str;
  879.    while ( *p != 0 )
  880.    {
  881.       if ( (*p == LBRACE) && (*(p+1) == RBRACE) ) p+=2;
  882.       else
  883.           *q++ = *p++;
  884.    }
  885.    *q = *p;
  886.    return;
  887. }
  888.  
  889. void RemoveTrailingSpace(str)
  890. char *str;
  891. {
  892.    char *p;
  893.    char *q;
  894.  
  895.    p = str; q = str;
  896.    while ( *p != 0 )
  897.    {
  898.       if ( (*p == SPACE) && (*(p+1) == RBRACE) ) p++;
  899.       else
  900.           *q++ = *p++;
  901.    }
  902.    *q = *p;
  903.    return;
  904. }
  905.  
  906. void doNDX(idx,str)
  907. int  idx;
  908. char str[];
  909. {
  910.    int  i,j;
  911.    char *p, *q, *r;
  912.    int  cur,e;
  913.    BYTE done;
  914.  
  915.    j = strlen(str);
  916.    p = &str[0]; p++; q = r = &string[0];
  917.    i = 0; e = 1; cur = E1;
  918.    xref = FALSE; alias = FALSE; crossref = FALSE;
  919.    done = FALSE; curEntry = OTHER_TYPE;
  920.    while ( !done && i<j )
  921.    {
  922.       switch ( *p )
  923.       {
  924.     case DQUOTE:
  925.          if ( *(p-1)==RSLASH ) 
  926.                   *q++ = *p;        
  927.          else
  928.          done = TRUE;
  929.          break;
  930.         case NL:
  931.          done = TRUE;
  932.          break;
  933.         case STAR:
  934.              *q++ = 0; 
  935.              if ( cur!=0 )
  936.          {
  937.                SkipSpacesReverse(j,q);
  938.            copyString(idx,cur,string); 
  939.            cur = 0;
  940.              }
  941.          q = r; 
  942.          p++; i++;
  943.              switch ( *p )
  944.          {
  945.            case ONE: case TWO: case THREE: case FOUR: case FIVE:
  946.             cur = GetSubLevel( (*p)-ZERO,*(p+1) ); p++; i++;
  947.                 q = r;
  948.             break;
  949.                case 'a':  
  950.             p++; i++; q = r;
  951.             curEntry = ALIAS_TYPE;
  952.             alias = TRUE;
  953.             cur = E1_ALIAS;
  954.             break;
  955.             case MINUS:
  956.             p++; i++; q = r;
  957.                 curEntry = PRE_TYPE;
  958.             cur = E1_PRE;
  959.             break;
  960.             case PLUS:
  961.              p++; i++; q = r;
  962.                  curEntry = POST_TYPE;
  963.              cur = E1_POST;
  964.              break;
  965.            case 'e': 
  966.             q = r;
  967.             curEntry = ENTRY_TYPE;
  968.             cur = E1_CS;
  969.             break;
  970.            case 'p': 
  971.             q = r;
  972.                 cur = CTRLSEQ;
  973.             break;
  974.            case 'f':  
  975.            case 'F':
  976.            case 't': 
  977.             q = r;
  978.             *q++ = *p; *q++ = 0;
  979.             copyString(idx,PAGE_SPAN,string);
  980.             q = r;
  981.             break;
  982.            case 'x': 
  983.             if ( crossref )
  984.             {
  985.                sprintf(msgbuf,"%s\n *x and *X can't occur together\n",
  986.                    str);
  987.                syntax_error(msgbuf);
  988.                 }
  989.                 strcpy(string,"x");    copyString(idx,XREF,string);
  990.             strcpy(string,"99999"); copyString(idx,NUMBER,string);
  991.             curEntry = XREF_TYPE; xref = TRUE;
  992.             q = r;
  993.             cur = CROSS_REF;
  994.             break;
  995.           case 'X':
  996.             if ( xref )
  997.             {
  998.                sprintf(msgbuf,"%s\n *x and *X can't occur together\n",
  999.                    str);
  1000.                syntax_error(msgbuf);
  1001.                 }
  1002.                    strcpy(string,"X");  copyString(idx,XREF,string);
  1003.            crossref = TRUE;
  1004.                cur = CROSS_REF; curEntry = XREF_TYPE;
  1005.            q = r;
  1006.            break;
  1007.           case RSLASH:
  1008.             cur = 0; break;
  1009.           default: 
  1010.             syntax_error(str);
  1011.             cur = 0;
  1012.                 break;
  1013.          }
  1014.          break;
  1015.         case COMMA:
  1016.              p++; i++; *q++ = 0;
  1017.              copyString(idx,cur,string);
  1018.          q = r;
  1019.          e++; cur = e*3 - 2;
  1020.          break;
  1021.        case LBRACE:
  1022.         switch ( curEntry )
  1023.         {
  1024.         case ALIAS_TYPE:    
  1025.         case PRE_TYPE:
  1026.         case POST_TYPE:
  1027.         case ENTRY_TYPE:
  1028.         case XREF_TYPE:
  1029.         case CROSS_TYPE:            
  1030.              break;
  1031.             default:
  1032.              *q++ = *p; break;
  1033.         }
  1034.         break;
  1035.        case RBRACE: 
  1036.         switch ( curEntry )
  1037.         {
  1038.         case ALIAS_TYPE:    
  1039.              alias = FALSE; 
  1040.         case PRE_TYPE:
  1041.         case POST_TYPE:
  1042.         case ENTRY_TYPE:
  1043.         case XREF_TYPE:
  1044.         case CROSS_TYPE:            
  1045.                      *q++ = 0; 
  1046.                      ReduceSpaces(string);
  1047.                  copyString(idx,cur,string); 
  1048.                  q = r; 
  1049.              curEntry = OTHER_TYPE; cur = 0;
  1050.              break;
  1051.             default:
  1052.              *q++ = *p; break;
  1053.         }
  1054.         break;
  1055.        case RSLASH:
  1056.         if ( *(p+1) == COMMA)
  1057.             {
  1058.            p++; i++; *q++ = *p;
  1059.         }
  1060.         else
  1061.           *q++ = *p;
  1062.             break;
  1063.        default:
  1064.         *q++ = *p;
  1065.         break;
  1066.        }
  1067.        p++; i++;
  1068.     }
  1069.    
  1070.    *q++ = 0;
  1071.    if ( cur!=0 )
  1072.    {
  1073.       SkipSpacesReverse(j,q);
  1074.       copyString(idx,cur,string); 
  1075.       cur = 0;
  1076.    }
  1077.  
  1078.    /* post processing of ndxfile */
  1079.    /* largest j with <entry_j>    */
  1080.    sprintf(string,"%d",e);
  1081.    copyString(idx,LARGEST,string);
  1082.  
  1083.    CheckAlias(idx);
  1084.    
  1085.    return;    
  1086. }
  1087.  
  1088.  
  1089. void doNPG(idx,str)
  1090. int  idx;
  1091. char str[];
  1092. {
  1093.    int  i,j,k;
  1094.    char *p, *q, *r;
  1095.    int  cur;
  1096.    char num[10],outstr[10];
  1097.  
  1098.    j = strlen(str);
  1099.    p = &str[0]; p++; q = r = &string[0]; i = 0; 
  1100.    while ( *p != RBRACE && i<j ) 
  1101.    {
  1102.       num[i++] = *p++;
  1103.    }
  1104.    num[i] = 0;
  1105.    strcpy(outstr,"0000");
  1106.    for (k=i; k>=0; k--)
  1107.    outstr[4-i+k] = num[k];
  1108.    for (k=0; k<5; k++)
  1109.    outstr[k];
  1110.    copyString(idx,NUMBER,outstr);
  1111.  
  1112.    p++; i++; cur = CSNAME; 
  1113.    while ( i<j && *p != NL )
  1114.    {
  1115.       switch ( *p )
  1116.       {
  1117.        case LBRACE:
  1118.         if ( *(p+1) != RBRACE )
  1119.              q = r;
  1120.         else { p++; i++; cur++; }
  1121.         break;
  1122.        case RBRACE: 
  1123.         *q++ = 0;
  1124.         copyString(idx,cur,string);
  1125.         cur++;
  1126.         break;
  1127.        default:
  1128.         *q++ = *p;
  1129.         break;
  1130.        }
  1131.        p++; i++;
  1132.    }
  1133.    return;    
  1134. }
  1135.  
  1136. char * CheckAbbrev(s,q)
  1137. char s[];
  1138. char *q;
  1139. {
  1140.   int  i,j,len;
  1141.   BYTE found;
  1142.   char *p;
  1143.   
  1144.   for (i=0, found=FALSE; i<nabb && !found; i++)
  1145.   {
  1146.     if ( stricmp(s,abbrev[i]->astr)==0 )
  1147.     {
  1148.     found = TRUE; p = abbrev[i]->xstr; len = strlen(abbrev[i]->xstr); 
  1149.     j = 0;
  1150.     while ( *p!=0 && j<len) 
  1151.     {
  1152.        *q++ = *p++; j++;
  1153.     }
  1154.     }
  1155.   }
  1156.   if ( !found )
  1157.   { sprintf(string,"syntax error! '%s' - not an \\abbrev",s); error(string); }
  1158.   return ( q );
  1159. }
  1160.  
  1161.  
  1162.  
  1163. /* preprocess NDX file for defines, abbrevs, page orders */
  1164. void PreProc()
  1165. {
  1166.    char buf[300],str[300];
  1167.    int    i,j,len;
  1168.    char *p, *q, *r;
  1169.    BYTE done, status;
  1170.  
  1171.    printMSG("preprocessing...");
  1172.    ndef = nabb = npo = 0 ;
  1173.    fgets(buf,300,ndxfile);
  1174.    while ( !feof(ndxfile) )
  1175.    {  
  1176.      len = strlen(buf);
  1177.      p = &buf[0];
  1178.      if ( strnicmp(p,"\\define",7)==0 )
  1179.      {
  1180.        buf[len-1]=0;
  1181.        if ( ndef >= MAX_DEFINES )
  1182.        {
  1183.       sprintf(string,
  1184.           "! number of defines (%d) exceeded MAXIMUM allowed (%d)",
  1185.           ndef,MAX_DEFINES);
  1186.       error( string );
  1187.        }
  1188.        define[ndef] = GetStringSpace(p);
  1189.        strcpy(define[ndef],p);
  1190.        ndef++;
  1191.      }
  1192.      else
  1193.      {
  1194.     if ( strnicmp(p,"\\abbrev",7)==0 )
  1195.     {
  1196.        buf[len-1]=0; p+=7;
  1197.        GetAbbrevSpace(nabb);
  1198.        j=0; q  = &buf[len-1];
  1199.  
  1200.        i=0;  /* remove spaces */
  1201.        while ( *p==SPACE && i<len )
  1202.        { p++; i++; }
  1203.  
  1204.        while ( *(p+j)!=LBRACE && *(p+j)!=SPACE && (p+j)<q ) j++; 
  1205.        *(p+j) = 0;
  1206.        abbrev[nabb]->astr = GetStringSpace(p);
  1207.        strcpy(abbrev[nabb]->astr,p);
  1208.  
  1209.        p += j+1; j = len-1;
  1210.        i=0;  /* remove spaces */
  1211.        while ( *p==SPACE && i<len )
  1212.        { p++; i++; }
  1213.  
  1214.        if ( *p==LBRACE ) p++;
  1215.        
  1216.        while ( *q!=RBRACE && q>p ) q--;
  1217.        *q = 0;
  1218.        abbrev[nabb]->xstr = GetStringSpace(p);
  1219.        strcpy(abbrev[nabb]->xstr,p);
  1220.        nabb++;
  1221.     }
  1222.     else
  1223.     {
  1224.            i=0;  /* remove spaces */
  1225.        while ( *p==SPACE && i<len )
  1226.        { p++; i++; }
  1227.      
  1228.        if ( strnicmp(p,"\\pageorder",10)==0 )
  1229.        {
  1230.          buf[len-1]=0; 
  1231.          p+=10;
  1232.          RemoveSpaces(p);
  1233.          GetPageOrderSpace(npo);
  1234.          /* get style */
  1235.          j=0; q  = &buf[len-1];
  1236.          while ( *(p+j)!=LBRACE && (p+j)<q ) 
  1237.          {   j++; }
  1238.          if ( (p+j) >= q )
  1239.            syntax_error(buf);
  1240.          *(p+j) = 0;
  1241.          PO[npo]->style = GetStringSpace(p);
  1242.          strcpy(PO[npo]->style,p);
  1243.          PO[npo]->nstyle = (BYTE) strlen(p);
  1244.  
  1245.          /* get pre page material */
  1246.          p += j+1; j=0;
  1247.          while ( *(p+j)!=RBRACE && (p+j)<q ) j++; 
  1248.          if ( (p+j) >= q )
  1249.         syntax_error(buf);
  1250.          *(p+j) = 0;
  1251.          if ( j==0 )
  1252.          { PO[npo]->pre = NULLPTR;  }
  1253.          else
  1254.          { PO[npo]->pre = GetStringSpace(p); strcpy(PO[npo]->pre,p); }
  1255.          PO[npo]->npre = (BYTE) strlen(p);
  1256.  
  1257.          /* get post page material */
  1258.          p += j+2; j=0;
  1259.          while ( *(p+j)!=RBRACE && (p+j)<q ) j++; 
  1260.          if ( (p+j) >= q )
  1261.         syntax_error(buf);
  1262.          *(p+j) = 0;
  1263.          if ( j==0 )
  1264.          { PO[npo]->post = NULLPTR; }
  1265.          else
  1266.          { PO[npo]->post = GetStringSpace(p); strcpy(PO[npo]->post,p); }
  1267.          PO[npo]->npost = (BYTE) strlen(p);
  1268.          
  1269.          /* get page order */
  1270.          p += j+1; 
  1271.          if ( *p==LBRACE ) 
  1272.          {    p++; q--; *q=0;  }
  1273.          PO[npo]->order =(BYTE) atoi(p);
  1274.          npo++;
  1275.            } /* endif page order */
  1276.        else
  1277.        {
  1278.         if ( *p!=NL && *p!=SPACE )
  1279.         {
  1280.          q = &string[0];
  1281.          done = FALSE; status = FALSE; i = 0;
  1282.          *q++ = *p++;
  1283.          while ( i<len )
  1284.          {
  1285.          switch ( *p )
  1286.          {
  1287.            case STAR:
  1288.             if ( *(p+1)==RSLASH )
  1289.             {
  1290.               r = &str[0]; done = FALSE;
  1291.               *r++ = *p++; *r++ = *p++;
  1292.               while ( !done )
  1293.               {
  1294.                switch ( *p )
  1295.                    {
  1296.             case SPACE: case DQUOTE: case COMMA: case LBRACE:
  1297.             case RBRACE: case LBRACKET: case RBRACKET:
  1298.             case LPAREN: case RPAREN: case QUOTE: case DOLLAR:
  1299.             case TILDE: case EXCLAIM: case CARET:
  1300.             case MINUS: case USCORE: case PLUS: case EQUAL:
  1301.             case COLON: case SEMI: case LQUOTE: case GREATER:
  1302.             case LESS: case QUESTION: case SLASH: case BAR:
  1303.             case STAR: case RSLASH: case PERIOD:
  1304.                  *r++=0;
  1305.                  done = TRUE;
  1306.                  break;
  1307.                 default:
  1308.                  *r++ = *p++; i++;
  1309.                      break;
  1310.                    } /* switch */
  1311.                   }  /* while */
  1312.               q=CheckAbbrev(str,q);
  1313.             } /* if */
  1314.             else
  1315.             {  *q++ = *p++; i++; }
  1316.             break;
  1317.            default:
  1318.             *q++ = *p++; i++;
  1319.             break;
  1320.          } /* switch */
  1321.           } /* while */
  1322.       *q++ = 0;
  1323.       PutString( string, xxxfile );
  1324.           } /* not NL or SPACE */
  1325.         } /* others */
  1326.        } /* else pageorders */
  1327.      } /* else abbrevs */
  1328.      fgets(buf,300,ndxfile);
  1329.    } /* while */
  1330.    return;    
  1331. }
  1332.  
  1333.  
  1334.  
  1335.  
  1336. /**********************************************************************/
  1337. /* BuildProc: read in contents of .ndx file into internal data buffers*/
  1338. /* Inputs   : .ndx file handle                                        */
  1339. /* Output   : Entries                                                 */
  1340. /**********************************************************************/
  1341. #ifndef SEEK_END
  1342. #define SEEK_END 2
  1343. #define SEEK_CUR 1
  1344. #define SEEK_SET 0
  1345. #endif
  1346. void BuildProc( void )
  1347. {
  1348.    char abuf[300];
  1349.    char bbuf[300];
  1350.    int  i;
  1351.  
  1352.    fseek(xxxfile, 0L, SEEK_SET);
  1353.    nitems = 0;
  1354.    fgets(abuf,300,xxxfile);
  1355.    while( !feof(xxxfile) )
  1356.    {
  1357.       nitems++;
  1358.       fgets( abuf,300,xxxfile );
  1359.    }
  1360.  
  1361.    nitems/=2;
  1362.    fseek(xxxfile, 0L, SEEK_SET);
  1363.    GetFieldSpace(0);
  1364.  
  1365.    for (i=1; i<=nitems; i++ )
  1366.    {
  1367.      fgets(abuf,300,xxxfile);
  1368.      fgets(bbuf,300,xxxfile);
  1369.      
  1370.      if ( bbuf[0]!='{' )
  1371.      {
  1372.           sprintf( msgbuf,"\n! Entry ->\n%s does not have a following \"{...}{...}{...}\" line.", abuf );
  1373.       error( msgbuf );
  1374.      }
  1375.      
  1376.      GetFieldSpace(i);
  1377.      ScanEntry( abuf );
  1378.      doNDX(i,abuf);    
  1379.      doNPG(i,bbuf);
  1380.      
  1381.    };
  1382.  
  1383.    return;
  1384. }
  1385.  
  1386.  
  1387.  
  1388. /**********************************************************************/
  1389. /* ScanEntry: scan entry line and delete entry delimiters             */
  1390. /* Inputs   : line                                                    */
  1391. /* Output   : line                                                    */
  1392. /**********************************************************************/
  1393. void ScanEntry( char line[] )
  1394. {
  1395. int   len,i;
  1396.   if ( line[0] == RSLASH )
  1397.   {
  1398.      sprintf( msgbuf,"Entry ->\n%s begins with a '\\'.", line );
  1399.      error( msgbuf );
  1400.   }
  1401.   else
  1402.     line[0] = SPACE;
  1403.   
  1404.   len = strlen( line );
  1405.   i = strlen(line) - 2;
  1406.   while( i>0 && line[i] == SPACE )
  1407.   {
  1408.     i--;
  1409.   }
  1410.   line[i] = SPACE;
  1411.   line[i] = NL;
  1412.   return;
  1413.   
  1414. }
  1415.  
  1416.  
  1417.  
  1418. int PageOrderSort(i,j)
  1419. int i, j;
  1420. {
  1421. int stat,n,k;
  1422. int i_order, j_order;
  1423.  
  1424.     i_order=GetPageOrder(i);
  1425.     j_order=GetPageOrder(j);
  1426.  
  1427.     stat = 0;
  1428.     for (n=PageOrderFirst; n<=PageOrderLast && stat==0; n++)
  1429.     {
  1430.      k = PageOrder[n];
  1431.      stat=strcmp(Entry[i].item->fields[k],Entry[j].item->fields[k]);
  1432.      switch ( k )
  1433.      {    
  1434.            case CSNAME:
  1435.        case PREFIX:
  1436.          if ( stat!= 0 ) 
  1437.          {
  1438.            if ( i_order < j_order ) return( -1 );
  1439.            if ( i_order > j_order ) return(  1 );
  1440.            return ( stat );
  1441.              }
  1442.              break;
  1443.        case NUMBER:
  1444.          if ( stat != 0 ) 
  1445.          {
  1446.           if ( (i_order == j_order) && (i_order == MAX_PAGEORDER) )
  1447.                return( stat );
  1448.           if ( (i_order == MAX_PAGEORDER) && (j_order < i_order) )
  1449.                return( 1 );
  1450.               if ( (j_order == MAX_PAGEORDER) && (i_order < j_order) )
  1451.                return( -1 );
  1452.           return( stat );
  1453.          }
  1454.          else
  1455.          {
  1456.             if ( i_order < j_order ) return( -1 );
  1457.             if ( i_order > j_order ) return(  1 );
  1458.          }
  1459.          break;
  1460.        case POSTFIX:
  1461.          if ( stat!= 0 ) 
  1462.          {
  1463.            if ( i_order < j_order ) return( -1 );
  1464.            if ( i_order > j_order ) return(  1 );
  1465.            return ( stat );
  1466.              }
  1467.              break;
  1468.        default:
  1469.              break;
  1470.         } /* switch */
  1471.  
  1472.      } /* for */
  1473.    return( stat );    
  1474. }
  1475.  
  1476. int CompareStrings(i,j)
  1477. int  i,j;
  1478. {
  1479. int n,k;    
  1480. int stat;
  1481.  
  1482.    stat=0;
  1483.    for (n=FirstOrder; n<=LastOrder && stat==0; n++)
  1484.    {
  1485.      k = SortingOrder[n];
  1486.      stat=stricmp(Entry[i].item->fields[k],Entry[j].item->fields[k]);
  1487.    }
  1488.  
  1489.    if ( stat==0 )
  1490.    {
  1491.       stat = PageOrderSort(i,j);
  1492.    } /* if */
  1493.    
  1494.    return( stat );
  1495. }
  1496.  
  1497.  
  1498. int GetPageOrder(idx)
  1499. int idx;
  1500. {
  1501. int i,done;    
  1502. int order;
  1503.    order = MAX_PAGEORDER;
  1504.    for (i=0,done=FALSE; i<npo && !done; i++)
  1505.    {
  1506.      if (  strncmp(Entry[idx].item->fields[CSNAME],PO[i]->style,
  1507.                 PO[i]->nstyle)==0
  1508.     && strncmp(Entry[idx].item->fields[PREFIX],PO[i]->pre,
  1509.             PO[i]->npre)==0
  1510.     && strncmp(Entry[idx].item->fields[POSTFIX],PO[i]->post,
  1511.             PO[i]->npost)==0 )
  1512.      {
  1513.        order = PO[i]->order; done = TRUE;
  1514.      }
  1515.    }
  1516.    return(order);
  1517. }
  1518.  
  1519.  
  1520. void SwapStrings(cur,nxt)
  1521. int  cur,nxt;
  1522. {
  1523.    int   k;
  1524.    char *p;
  1525.    for (k=E1; k<=CROSS_REF; k++)
  1526.    {
  1527.     p = Entry[cur].item->fields[k];
  1528.     Entry[cur].item->fields[k] = Entry[nxt].item->fields[k];
  1529.     Entry[nxt].item->fields[k] = p;
  1530.    }
  1531.    return;
  1532. }
  1533.  
  1534. void SortProc()
  1535. {
  1536. int  i,j,n;
  1537. FILE *f;
  1538. int  gap;
  1539.  
  1540.   printMSG("sorting...");
  1541.   
  1542.   /* Shell sort */
  1543.   n = nitems+1;
  1544.   for ( gap=n/2; gap>0; gap/=2 )
  1545.   {
  1546.      for ( i=gap; i<n; i++ )
  1547.      {
  1548.     for ( j=i-gap; j>0 && CompareStrings(j,j+gap) > 0; j-=gap )
  1549.     {
  1550.         SwapStrings(j,j+gap);
  1551.     }
  1552.      }
  1553.   }
  1554.   
  1555.   /* write out sorted list - this is for debugging only */
  1556.   if ( idxfile )
  1557.   {
  1558.     f = fopen(idxname,"w");
  1559.     if ( f==NULL )
  1560.     { sprintf(string,"File write error %s",idxname); error(string); }
  1561.     for (i=1; i<=nitems; i++)
  1562.     { 
  1563.     BuildString(i); 
  1564.     PutString( string, f ); PutByte( NL, f);
  1565.     }
  1566.     fclose(f);
  1567.   }
  1568.  
  1569.   return;    
  1570. }
  1571.  
  1572.  
  1573. int CompareStringsPO(i,j)
  1574. int  i,j;
  1575. {
  1576. int stat;
  1577.    stat = PageOrderSort(i,j);
  1578.    return( stat );
  1579. }
  1580.  
  1581.  
  1582. /**********************************************************************/
  1583. /* Sort Page Numbers                                              */
  1584. /* Inputs: beginning entry, ending entry                              */
  1585. /* Output: Sorted list of page numbers entries                        */
  1586. /**********************************************************************/
  1587. void SortPageNumber(beg,end)
  1588.  int beg, end;
  1589. {
  1590. int  i,j,k,n;
  1591. int  change,status;
  1592.  
  1593.   /* Check for boundary conditions */
  1594.   if ( ( end - beg )  >= MAX_PAGEENTRY )
  1595.   {
  1596.      sprintf(string,"! page line entries (%d) exceeded MAXIMUM allowed (%d)",
  1597.          end-beg,MAX_PAGEENTRY );
  1598.      error( string );
  1599.   }
  1600.   
  1601.   n = 0;
  1602.   for (i=beg; i<end; i++)
  1603.   {
  1604.      if ( *(Entry[i].item->fields[XREF])!='x' )
  1605.      {
  1606.        SubPageOrder[n] = i; n++;
  1607.      }
  1608.   }
  1609.  
  1610.   /* Refined Bubble sort - for simplicity  
  1611.      Note: we only need to sort a subset of the entries. 
  1612.            Sorting is done using an array of indices without
  1613.        physically swapping entries. */
  1614.   change = TRUE;    
  1615.   for (i=0; i<n && change; i++)
  1616.   {
  1617.      change = FALSE;
  1618.      for (j=0;j<n-1;j++)
  1619.      {
  1620.        status = CompareStringsPO(SubPageOrder[j],SubPageOrder[j+1]);
  1621.        if ( status>0 )
  1622.        { 
  1623.      k = SubPageOrder[j+1];
  1624.      SubPageOrder[j+1] = SubPageOrder[j];
  1625.      SubPageOrder[j] = k;
  1626.      change=TRUE; }
  1627.      }
  1628.   }
  1629.  
  1630.   return;
  1631. }
  1632.  
  1633.  
  1634. BYTE CheckLevel(cur,idx,level)
  1635. int  cur,idx;
  1636. BYTE level;
  1637. {
  1638. BYTE entry_i, pre_i, post_i, alias_i, cs_i;
  1639.  
  1640.   switch ( level )
  1641.   {
  1642.      case LEVEL1:
  1643.           entry_i = E1; pre_i = E1_PRE; post_i = E1_POST;
  1644.           alias_i = E1_ALIAS; cs_i = E1_CS;
  1645.       break;
  1646.      case LEVEL2:
  1647.           entry_i = E2; pre_i = E2_PRE; post_i = E2_POST;
  1648.           alias_i = E2_ALIAS; cs_i = E2_CS;
  1649.       break;
  1650.      case LEVEL3:
  1651.           entry_i = E3; pre_i = E3_PRE; post_i = E3_POST;
  1652.           alias_i = E3_ALIAS; cs_i = E3_CS;
  1653.       break;
  1654.      case LEVEL4:
  1655.           entry_i = E4; pre_i = E4_PRE; post_i = E4_POST;
  1656.           alias_i = E4_ALIAS; cs_i = E4_CS;
  1657.       break;
  1658.      case LEVEL5:
  1659.           entry_i = E5; pre_i = E5_PRE; post_i = E5_POST;
  1660.           alias_i = E5_ALIAS; cs_i = E5_CS;
  1661.       break;
  1662.   }
  1663.  
  1664.   if (  strcmp(Entry[cur].item->fields[entry_i],
  1665.     Entry[idx].item->fields[entry_i])==0
  1666.      && strcmp(Entry[cur].item->fields[pre_i],
  1667.     Entry[idx].item->fields[pre_i])  ==0
  1668.      && strcmp(Entry[cur].item->fields[post_i],
  1669.     Entry[idx].item->fields[post_i]) ==0
  1670.      && strcmp(Entry[cur].item->fields[alias_i],
  1671.     Entry[idx].item->fields[alias_i])==0
  1672.      && strcmp(Entry[cur].item->fields[cs_i],
  1673.     Entry[idx].item->fields[cs_i])   ==0
  1674.      )
  1675.      return(TRUE); 
  1676.   else
  1677.      return(FALSE);
  1678. }
  1679.  
  1680.  
  1681. BYTE GetD2(cur,idx)
  1682. int  cur;
  1683. int  idx;
  1684. {
  1685.   if ( CheckLevel( cur,idx,LEVEL1 ) )
  1686.   {
  1687.       if ( CheckLevel( cur,idx,LEVEL2 ) )    
  1688.       {
  1689.           if ( CheckLevel( cur,idx,LEVEL3)  )
  1690.       {
  1691.          if ( CheckLevel( cur,idx,LEVEL4 ) )
  1692.          {
  1693.          if ( CheckLevel ( cur,idx,LEVEL5 ) )
  1694.               return(LEVEL5);
  1695.              else return(LEVEL4);
  1696.          }
  1697.          else return(LEVEL3);
  1698.       }
  1699.       else return(LEVEL2);
  1700.       }
  1701.       else return(LEVEL1);
  1702.    }
  1703.    else return(LEVEL0);
  1704.  
  1705.    return(LEVEL0);    
  1706. }
  1707.  
  1708.  
  1709.  
  1710.  
  1711. void GetArg(idx,arg,pre,cs,entry,post,alias)
  1712. int  idx;
  1713. char arg[];
  1714. BYTE pre,cs,entry,post,alias;
  1715. {
  1716.    if ( Entry[idx].item->fields[alias]!=NULLPTR )
  1717.      entry = alias;
  1718.  
  1719.    if ( Entry[idx].item->fields[cs]==NULLPTR )
  1720.    {
  1721.        if ( Entry[idx].item->fields[pre]==NULLPTR
  1722.      && Entry[idx].item->fields[post]==NULLPTR )
  1723.             sprintf(arg,"{%s}",Entry[idx].item->fields[entry]);
  1724.        else
  1725.            sprintf(arg,"{{%s}{%s}{%s}}",Entry[idx].item->fields[pre],
  1726.            Entry[idx].item->fields[entry],Entry[idx].item->fields[post]);
  1727.    }
  1728.    else
  1729.    {
  1730.        sprintf(arg,"{{%s}{%s{%s}}{%s}}",Entry[idx].item->fields[pre],
  1731.            Entry[idx].item->fields[cs],
  1732.            Entry[idx].item->fields[entry],Entry[idx].item->fields[post]);
  1733.    }
  1734.  
  1735.    RemoveEmptySet(arg);
  1736.  
  1737.    return;
  1738. }
  1739.  
  1740.  
  1741. void DoNormal(idx,arg)
  1742. int  idx;
  1743. char arg[];
  1744. {
  1745. char *p;
  1746. char str[80];
  1747. int  pn;
  1748.  
  1749.    pn = atoi(Entry[idx].item->fields[NUMBER]);
  1750.    strcpy( str, Entry[idx].item->fields[CSNAME] );
  1751.    p = &str[0];
  1752.    if ( strncmp(p,"\\arabic",7)==0 ) *p=0;
  1753.  
  1754.    if ( Entry[idx].item->fields[CTRLSEQ]==NULLPTR )
  1755.    {
  1756.       if ( Entry[idx].item->fields[PREFIX]==NULLPTR
  1757.     && Entry[idx].item->fields[POSTFIX]==NULLPTR )
  1758.       {
  1759.       if ( *p==0 )
  1760.              sprintf(arg,"{%d}",pn);
  1761.           else
  1762.              sprintf(arg,"{%s{%d}}",p,pn);          
  1763.       }
  1764.       else
  1765.       {  
  1766.       if ( *p==0 )
  1767.               sprintf(arg,"{{%s}{%d}{%s}}",
  1768.                   Entry[idx].item->fields[PREFIX],pn,
  1769.               Entry[idx].item->fields[POSTFIX]);
  1770.       else
  1771.               sprintf(arg,"{{%s}{%s{%d}}{%s}}",
  1772.                       Entry[idx].item->fields[PREFIX],p,pn,
  1773.               Entry[idx].item->fields[POSTFIX]);
  1774.       }
  1775.    }
  1776.    else
  1777.    {
  1778.       if ( Entry[idx].item->fields[PREFIX]==NULLPTR 
  1779.     && Entry[idx].item->fields[POSTFIX]==NULLPTR )
  1780.       {
  1781.       if ( *p == 0 )
  1782.                sprintf(arg,"{%s{%d}}",Entry[idx].item->fields[CTRLSEQ],pn);
  1783.           else
  1784.                sprintf(arg,"{%s{%s{%d}}}",Entry[idx].item->fields[CTRLSEQ],
  1785.                p,pn);
  1786.       }
  1787.       else
  1788.       {
  1789.       if ( *p == 0 )
  1790.               sprintf(arg,"{%s{{%s}{%d}{%s}}}",
  1791.                   Entry[idx].item->fields[CTRLSEQ],
  1792.                       Entry[idx].item->fields[PREFIX],pn,
  1793.               Entry[idx].item->fields[POSTFIX]);
  1794.       else
  1795.              sprintf(arg,"{%s{{%s}{%s{%d}}{%s}}}",
  1796.              Entry[idx].item->fields[CTRLSEQ],
  1797.                      Entry[idx].item->fields[PREFIX],p,pn,
  1798.              Entry[idx].item->fields[POSTFIX]);
  1799.       }
  1800.    }
  1801.    return;
  1802. }
  1803.  
  1804.  
  1805. void DoVariant(idx,arg)
  1806. int  idx;
  1807. char arg[];
  1808. {
  1809. char *p;
  1810. int  pn;
  1811. char str[80];
  1812.  
  1813.    pn = atoi(Entry[idx].item->fields[NUMBER]);
  1814.    strcpy(str,Entry[idx].item->fields[CSNAME]);
  1815.    p = &str[0];
  1816.    if ( strncmp(p,"\\arabic",7)==0 ) *p=0;
  1817.  
  1818.    if ( Entry[idx].item->fields[PREFIX]==NULLPTR 
  1819.      && Entry[idx].item->fields[POSTFIX]==NULLPTR )
  1820.    {
  1821.       if ( *p==0 )
  1822.          sprintf(arg,"{%s }{%d}",Entry[idx].item->fields[CTRLSEQ],pn);
  1823.       else
  1824.          sprintf(arg,"{%s }{%s{%d}}",Entry[idx].item->fields[CTRLSEQ],p,pn);
  1825.    }
  1826.    else
  1827.    {  
  1828.       if ( *p==0 )
  1829.            sprintf(arg,"{%s }{{%s}{%d}{%s}}",
  1830.                Entry[idx].item->fields[CTRLSEQ],
  1831.                    Entry[idx].item->fields[PREFIX],pn,
  1832.                Entry[idx].item->fields[POSTFIX]);
  1833.       else
  1834.            sprintf(arg,"{%s }{{%s}{%s{%d}}{%s}}",
  1835.                Entry[idx].item->fields[CTRLSEQ],
  1836.            Entry[idx].item->fields[PREFIX],
  1837.                p,pn,Entry[idx].item->fields[POSTFIX]);
  1838.    }
  1839.    return;
  1840. }
  1841.  
  1842.  
  1843. void  PrintErrorMSG()
  1844. {
  1845. int i;
  1846.  
  1847.    PutString( "%% ",xdxfile );
  1848.    for (i=0; i<72; i++) 
  1849.     PutByte('/',xdxfile);
  1850.    PutByte( NL, xdxfile );
  1851.    PutString("%%\n",xdxfile);
  1852.    PutString( msgbuf,xdxfile );
  1853.    PutString("%%\n",xdxfile);
  1854.    PutString("%% ",xdxfile); 
  1855.    for (i=0; i<72; i++) 
  1856.     PutByte('\\',xdxfile);
  1857.    PutByte( NL, xdxfile);
  1858.  
  1859.    return;
  1860. }
  1861.  
  1862.  
  1863. int DupPageFormat(idx,arg)
  1864. int idx;
  1865. char arg[];
  1866. {
  1867. int  i,level;
  1868. BYTE done;
  1869. char tmpbuf[300];
  1870.  
  1871.   for (i=idx-1, done=FALSE; i>0 && !done; i--)
  1872.   {
  1873.     level = GetD2(i,idx);
  1874.     if ( level==LEVEL5 ) 
  1875.     {
  1876.       if ( strcmp(Entry[idx].item->fields[NUMBER],
  1877.             Entry[i].item->fields[NUMBER])==0 
  1878.     &&  strcmp(Entry[idx].item->fields[CTRLSEQ],
  1879.                Entry[i].item->fields[CTRLSEQ])!=0 )
  1880.       {
  1881.        RemoveEmptySet(arg);
  1882.        sprintf(msgbuf,"%%  \\Page %s\n",arg);
  1883.        sprintf(tmpbuf,
  1884.         "%%  Duplicate page number formatted differently\n");
  1885.        strcat(msgbuf,tmpbuf);
  1886.        PrintErrorMSG();
  1887.        done = TRUE;
  1888.        return( FALSE );
  1889.      } /* if */
  1890.    } /* if - level */
  1891.    else 
  1892.       done = TRUE;
  1893.   } /* for */
  1894.   return(TRUE);
  1895. }
  1896.  
  1897.  
  1898. /**********************************************************************/
  1899. /* Find The Last matching t entry                                     */
  1900. /* Inputs: index into current entry                                   */
  1901. /* Output: TRUE if found, FALSE if not                                */
  1902. /**********************************************************************/
  1903. int FindLastT(idx)
  1904. int idx;
  1905. {
  1906. int i,level,done;
  1907.  
  1908.   Tindex = 0; done = FALSE; 
  1909.   level = GetD2(idx-1,idx);
  1910.   for ( i=idx-1;
  1911.         ( i>0 ) && ( level==LEVEL5 ) && !done ;
  1912.     i-- )
  1913.   {
  1914.     done = TRUE;
  1915.     if (   strcmp(Entry[idx].item->fields[NUMBER],
  1916.                  Entry[i].item->fields[NUMBER])==0 
  1917.     && strcmp(Entry[idx].item->fields[PAGE_SPAN],
  1918.                  Entry[i].item->fields[PAGE_SPAN])==0 )
  1919.     {
  1920.        Tindex = i; done = FALSE;
  1921.     }
  1922.     level = GetD2(i-1,idx);
  1923.     
  1924.   }
  1925.  
  1926.   if ( Tindex != 0 )
  1927.        return( TRUE );
  1928.   else
  1929.        return( FALSE );
  1930.  
  1931. }
  1932.  
  1933.  
  1934.  
  1935. BYTE GetPageNum(idx)
  1936. int  idx;
  1937. {
  1938. char type;
  1939. char arg[300];
  1940. int  status;
  1941. char tmpbuf[300];
  1942.  
  1943.    type = *(Entry[idx].item->fields[PAGE_SPAN]); skippage = FALSE;
  1944.    switch ( type )
  1945.    {
  1946.      case 'F':
  1947.     DoVariant(idx,arg);
  1948.     if ( PageType=='f' || PageType=='F' )
  1949.     {
  1950.           sprintf(msgbuf,"%%  \\Pagespan %s\n",arg);
  1951.       sprintf(tmpbuf,
  1952.               "%%  Page span starting at %s within span starting at %d\n",
  1953.           arg,atoi(Entry[PageIndex].item->fields[NUMBER]));    
  1954.       strcat(msgbuf,tmpbuf);
  1955.       PrintErrorMSG();
  1956.       skippage = TRUE;
  1957.       return(FALSE);
  1958.     }
  1959.     
  1960.     PageType = type ; PageIndex = idx;
  1961.         PageSpan = TRUE;
  1962.     break;
  1963.   case 'f': 
  1964.       DoNormal(idx,arg);      
  1965.       if ( PageType=='f' || PageType=='F' )
  1966.       {
  1967.        sprintf(msgbuf,"%%  \\Pagespan %s\n",arg);
  1968.        sprintf(tmpbuf,
  1969.            "%%  Page span starting at %s within span starting at %d\n",
  1970.             arg,atoi(Entry[PageIndex].item->fields[NUMBER]));    
  1971.        strcat(msgbuf,tmpbuf);
  1972.        PrintErrorMSG();
  1973.        skippage = TRUE;
  1974.        return(FALSE);
  1975.       }
  1976.       
  1977.       PageType = type ; PageIndex = idx;
  1978.       PageSpan = TRUE;
  1979.     break;
  1980.   case 't':
  1981.     switch ( PageType ) 
  1982.     {
  1983.       case 'F': 
  1984.     DoVariant(idx,arg); 
  1985.         break;
  1986.       case 'f': 
  1987.     DoNormal(idx,arg); 
  1988.         break;
  1989.       default: 
  1990.     DoNormal(idx,arg); 
  1991.  
  1992.         if ( FindLastT(idx)  )
  1993.     {
  1994.      sprintf(msgbuf,"%%  \\Topage %s\n",arg);
  1995.      sprintf(tmpbuf,
  1996.             "%%  Span ending at %s also ending at {%s {%d}}\n",
  1997.         arg,
  1998.         Entry[Tindex].item->fields[CTRLSEQ],
  1999.         atoi(Entry[Tindex].item->fields[NUMBER]));
  2000.      strcat(msgbuf,tmpbuf);
  2001.      PrintErrorMSG();
  2002.      skippage = TRUE;
  2003.          PageType = 0; PageIndex = 0; PageSpan = FALSE;
  2004.      return(FALSE); 
  2005.     }
  2006.     
  2007.     sprintf(msgbuf,"%%  \\Topage %s\n",arg);
  2008.     sprintf(tmpbuf,
  2009.             "%%  Page span ending at %s has no starting page\n",
  2010.         arg);
  2011.     strcat(msgbuf,tmpbuf);
  2012.     PrintErrorMSG();
  2013.     skippage = TRUE;
  2014.         PageType = 0; PageIndex = 0; PageSpan = FALSE;       
  2015.     return(FALSE); 
  2016.       break;
  2017.     } /* switch */
  2018.  
  2019.     break;
  2020.   default: 
  2021.      DoNormal(idx,arg); 
  2022.      if ( PageSpan )
  2023.      {
  2024.        /* Drop it if within page span */
  2025.        status = stricmp(Entry[idx].item->fields[CTRLSEQ],
  2026.                     Entry[PageIndex].item->fields[CTRLSEQ]);
  2027.        if ( status == 0 )
  2028.       return( FALSE );
  2029.        else
  2030.        {
  2031.          sprintf(msgbuf,
  2032.              "%%  Page %s%s within span starting at {%s {%d}}\n",
  2033.          Entry[idx].item->fields[CTRLSEQ],arg,
  2034.          Entry[PageIndex].item->fields[CTRLSEQ],
  2035.          atoi(Entry[PageIndex].item->fields[NUMBER]));
  2036.     PrintErrorMSG();
  2037.     skippage = TRUE;    
  2038.     return( FALSE );
  2039.        } /* else */
  2040.      } /* if */
  2041.      status = DupPageFormat(idx,arg);
  2042.      if ( !status )
  2043.        return( FALSE );
  2044.      break;
  2045.   } /* switch */
  2046.    
  2047.   RemoveEmptySet(arg);
  2048.  
  2049.   strcpy(prevnum,pagenum);
  2050.   strcpy(pagenum,arg);
  2051.    
  2052.   return(TRUE);
  2053.  
  2054. }
  2055.  
  2056.  
  2057. void PutPageNum(idx)
  2058. int  idx;
  2059. {
  2060. char c;
  2061. char str[80];
  2062.  
  2063.    if ( skippage ) return;
  2064.    
  2065.    c =  *(Entry[idx].item->fields[PAGE_SPAN]) ;
  2066.    switch ( c )
  2067.    {
  2068.       case 'f':
  2069.        sprintf(str,"\\Pagespan %s\n",pagenum);
  2070.        PutString( str, xdxfile );
  2071.        break;
  2072.       case 'F':
  2073.        sprintf(str,"\\PageSpan %s\n",pagenum);
  2074.        PutString( str, xdxfile );
  2075.        break;
  2076.       case 't':
  2077.        sprintf(str,"\\Topage %s\n",pagenum);
  2078.        PutString( str, xdxfile );
  2079.        if ( strcmp( Entry[idx].item->fields[CTRLSEQ],
  2080.                 Entry[PageIndex].item->fields[CTRLSEQ] ) !=0 )
  2081.        {
  2082.         sprintf(msgbuf,"%%  \\Page span from {%s {%d}} to %s\n",
  2083.             Entry[PageIndex].item->fields[CTRLSEQ],
  2084.             atoi(Entry[PageIndex].item->fields[NUMBER]),
  2085.             pagenum);
  2086.         PrintErrorMSG();
  2087.        }
  2088.            PageType = 0; PageIndex = 0; PageSpan = FALSE;
  2089.        break;          
  2090.         default:          
  2091.        sprintf(str,"\\Page %s\n",pagenum);
  2092.        PutString( str, xdxfile );
  2093.            break;
  2094.    }
  2095.    return;
  2096. }
  2097.  
  2098.  
  2099. void GetArgs(idx,arg1,arg2,arg3,arg4,arg5)
  2100. int  idx;
  2101. char *arg1, *arg2, *arg3, *arg4, *arg5;
  2102. {
  2103.    GetArg(idx,arg1,E1_PRE,E1_CS,E1,E1_POST,E1_ALIAS);
  2104.    GetArg(idx,arg2,E2_PRE,E2_CS,E2,E2_POST,E2_ALIAS);
  2105.    GetArg(idx,arg3,E3_PRE,E3_CS,E3,E3_POST,E3_ALIAS);
  2106.    GetArg(idx,arg4,E4_PRE,E4_CS,E4,E4_POST,E4_ALIAS);
  2107.    GetArg(idx,arg5,E5_PRE,E5_CS,E5,E5_POST,E5_ALIAS);
  2108.    return;
  2109. }
  2110.  
  2111.  
  2112. int DupEntry( idx, cur )
  2113. int idx,cur;
  2114. {
  2115.   int i,k,stat;
  2116.   
  2117.  
  2118.   for (i=cur; i<idx; i++)
  2119.   {
  2120.     stat=0;
  2121.     
  2122.     for (k=E1; k<=CROSS_REF && stat==0; k++)
  2123.     {
  2124.      stat=stricmp(Entry[i].item->fields[k],Entry[idx].item->fields[k]);
  2125.     }
  2126.     
  2127.     if ( stat == 0 )
  2128.      return( TRUE );
  2129.     
  2130.   } /* for */
  2131.   
  2132.   if ( stat == 0 )
  2133.        return( TRUE );
  2134.   else return ( FALSE );
  2135.   
  2136. } /* end - DupEntry */
  2137.  
  2138.  
  2139. int DupXref( idx, cur )
  2140. int idx,cur;
  2141. {
  2142.   int i;
  2143.   for (i=idx; i<cur; i++)
  2144.   {
  2145.      if ( stricmp( Entry[i].item->fields[CROSS_REF], 
  2146.                Entry[cur].item->fields[CROSS_REF] ) == 0 )
  2147.       return( TRUE );
  2148.   }
  2149.   
  2150.   return ( FALSE );
  2151.   
  2152. } /* end - DupXref */
  2153.  
  2154.  
  2155. void xxref_proc(idx)
  2156. int  idx;
  2157. {
  2158. int  i,d2,nxt,level,n;
  2159. BYTE done;
  2160. char xtype;
  2161. int  status;
  2162.  
  2163.    /* put out 1 cross reference */
  2164.    GetArgs(idx,arg1,arg2,arg3,arg4,arg5);
  2165.    d2 = GetD2(idx,idx-1);
  2166.    sprintf(msgbuf,"\\Entry %s%d%s%s%s%s%s\n",
  2167.            Entry[idx].item->fields[LARGEST],d2,arg1,arg2,arg3,arg4,arg5);
  2168.    PutString( msgbuf, xdxfile );
  2169.    
  2170.    sprintf(msgbuf,"\\Xref {\\See {%s}}\n",
  2171.        Entry[idx].item->fields[CROSS_REF]);
  2172.    PutString( msgbuf, xdxfile );
  2173.    
  2174.    
  2175.    /* Gather all the cross references */
  2176.    nxt = 1; done = FALSE;
  2177.    while ( !done && (idx+nxt)<=nitems )
  2178.    {
  2179.      level = GetD2(idx,idx+nxt);
  2180.      xtype = (char) *(Entry[idx+nxt].item->fields[XREF]);
  2181.      if ( level==LEVEL5 && ( xtype=='X' || xtype=='x' ) )
  2182.      {
  2183.        if ( !DupXref(idx, idx+nxt) )
  2184.        {
  2185.             sprintf(msgbuf,"\\Morexref {\\See {%s}}\n",
  2186.                 Entry[idx+nxt].item->fields[CROSS_REF]);
  2187.         PutString( msgbuf, xdxfile );
  2188.        }
  2189.        nxt++;
  2190.      }
  2191.      else
  2192.      {
  2193.         done = TRUE;
  2194.      }
  2195.    }
  2196.  
  2197.    SortPageNumber(idx,idx+nxt);
  2198.    n = 0;
  2199.    for ( i=idx; i<idx+nxt; i++)
  2200.    {
  2201.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2202.      if ( xtype != 'x' )
  2203.      {
  2204.        status = GetPageNum(SubPageOrder[n]);
  2205.        if ( status ) PutPageNum(SubPageOrder[n]);
  2206.        n++;
  2207.      }
  2208.    }
  2209.  
  2210.    /* put out cross references again */
  2211.    sprintf(msgbuf,"\\Xref {\\See {%s}}\n",
  2212.            Entry[idx].item->fields[CROSS_REF]);
  2213.    PutString( msgbuf, xdxfile );
  2214.      
  2215.      
  2216.    for ( i=idx+1; i<idx+nxt; i++)
  2217.    {
  2218.      level = GetD2(i,idx);
  2219.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2220.      if ( level==LEVEL5 && ( xtype=='X' || xtype=='x' ) )
  2221.      {
  2222.        if ( !DupXref(idx,i) )
  2223.        {
  2224.             sprintf(msgbuf,"\\Morexref {\\See {%s}}\n",
  2225.                 Entry[i].item->fields[CROSS_REF]);
  2226.         PutString( msgbuf, xdxfile );
  2227.        }
  2228.      } /* if */
  2229.    } /* for */
  2230.    
  2231.    curIndex = idx + nxt;
  2232.    return;
  2233. } /* xxref_proc */
  2234.  
  2235.  
  2236. void xref_proc(idx)
  2237. int  idx;
  2238. {
  2239. int  nxt,level,d2,i;
  2240. BYTE done;
  2241. char xtype;
  2242. BYTE ctype;
  2243.    
  2244.    /* CASE I or CASE II */
  2245.    nxt = 1; done = FALSE; ctype = 1;
  2246.    while ( !done && (idx+nxt)<=nitems )
  2247.    {
  2248.      level = GetD2(idx+nxt,idx);
  2249.      xtype = (char) *(Entry[idx+nxt].item->fields[XREF]);
  2250.      if ( level==LEVEL5 && ( xtype=='X' || xtype =='x') )
  2251.      {
  2252.        if ( xtype == 'X' )
  2253.             ctype = 2;
  2254.        nxt++;
  2255.      }
  2256.      else
  2257.      {
  2258.         done = TRUE;
  2259.      }
  2260.    } /* while */
  2261.  
  2262.  /* CASE I */
  2263.  if ( ctype == 1 )
  2264.  {
  2265.    /* put out 1 cross reference */
  2266.    GetArgs(idx,arg1,arg2,arg3,arg4,arg5);
  2267.    d2 = GetD2(idx,idx-1);
  2268.    
  2269.    sprintf(msgbuf,"\\Entryxref %s%d%s%s%s%s%s{\\See {%s}}\n",
  2270.            Entry[idx].item->fields[LARGEST],d2,arg1,arg2,arg3,arg4,arg5,
  2271.         Entry[idx].item->fields[CROSS_REF]); 
  2272.    PutString( msgbuf, xdxfile );
  2273.    
  2274.  
  2275.    /* Gather up all the cross references */
  2276.    for ( i=idx+1; i<idx+nxt; i++ )
  2277.    {
  2278.      level = GetD2(i,idx);
  2279.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2280.      if ( level==LEVEL5 && xtype=='x' )
  2281.      {
  2282.        if ( !DupXref(idx,i) )
  2283.        {
  2284.                sprintf(msgbuf,"\\Morexref {\\See {%s}}\n",
  2285.                Entry[i].item->fields[CROSS_REF]);
  2286.            PutString( msgbuf, xdxfile );
  2287.        }
  2288.      }
  2289.      else
  2290.      {
  2291.         done = TRUE;
  2292.      }
  2293.    } /* while */
  2294.    
  2295.    curIndex = idx + nxt;
  2296.    
  2297.  } /* if */
  2298.  
  2299.  /* CASE II */
  2300.  else
  2301.  {
  2302.    xxref_proc( idx );
  2303.  }
  2304.  
  2305.    return;
  2306. } /* end  - xref_proc */
  2307.  
  2308.  
  2309. void OutputProc(idx,arg1,arg2,arg3,arg4,arg5)
  2310. int  idx;
  2311. char *arg1, *arg2, *arg3, *arg4, *arg5;
  2312. {
  2313. int d2, status;
  2314.  
  2315.    d2 = GetD2(idx,idx-1);
  2316.    if ( d2==LEVEL5 )
  2317.    {
  2318.       if ( !DupEntry( idx, idx-1 ) )
  2319.       {
  2320.         status = GetPageNum(idx);
  2321.         if ( status )  PutPageNum(idx);
  2322.       }
  2323.    }
  2324.    else
  2325.    {
  2326.      sprintf(msgbuf,"\\Entry %s%d%s%s%s%s%s\n",
  2327.              Entry[idx].item->fields[LARGEST],d2,arg1,arg2,arg3,arg4,arg5);
  2328.      PutString( msgbuf, xdxfile );
  2329.      status = GetPageNum(idx);
  2330.      if ( status ) PutPageNum(idx);
  2331.    }
  2332.    return;    
  2333. } /* end - OutputProc */
  2334.  
  2335.  
  2336. void other_proc(idx)
  2337. int  idx;
  2338. {
  2339. int  i,d2,nxt,level,n;
  2340. BYTE done,first;
  2341. char xtype,ctype;
  2342. int  status;
  2343.  
  2344.  
  2345.    /* this is the last line */
  2346.    if ( idx+1 > nitems )
  2347.    {
  2348.      /* finish up and exits */
  2349.      GetArgs(idx,arg1,arg2,arg3,arg4,arg5);
  2350.      OutputProc(idx,arg1,arg2,arg3,arg4,arg5);
  2351.      curIndex++;
  2352.      return;
  2353.    }
  2354.  
  2355.    /* Get all the LEVEL5 entries */
  2356.    nxt = 1; done = FALSE; ctype = FALSE;
  2357.    while ( !done && (idx+nxt)<=nitems )
  2358.    {
  2359.      level = GetD2(idx+nxt,idx);
  2360.      xtype = (char) *(Entry[idx+nxt].item->fields[XREF]);
  2361.      if ( level==LEVEL5 )
  2362.      {
  2363.     if ( xtype == 'X' || xtype == 'x' )
  2364.        ctype = TRUE;
  2365.         nxt++;
  2366.      }
  2367.      else
  2368.      {
  2369.         done = TRUE;
  2370.      }
  2371.    }
  2372.  
  2373.    if ( !ctype )
  2374.    {
  2375.      /* Not a cross reference, so we output line and return */
  2376.      GetArgs(idx,arg1,arg2,arg3,arg4,arg5);
  2377.      OutputProc(idx,arg1,arg2,arg3,arg4,arg5);
  2378.      curIndex++;
  2379.      return;
  2380.    }
  2381.    
  2382.    /* put out entry first */
  2383.    GetArgs(idx,arg1,arg2,arg3,arg4,arg5);
  2384.    d2 = GetD2(idx,idx-1);
  2385.    sprintf(msgbuf,"\\Entry %s%d%s%s%s%s%s\n",
  2386.            Entry[idx].item->fields[LARGEST],d2,arg1,arg2,arg3,arg4,arg5);
  2387.    PutString( msgbuf, xdxfile );
  2388.  
  2389.    /* Gather all the cross references */
  2390.    first = TRUE;
  2391.    for (i=idx+1; i<idx+nxt; i++ )
  2392.    {
  2393.      level = GetD2(i,idx);
  2394.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2395.      if ( level==LEVEL5 && ( xtype=='X' || xtype=='x' ) )
  2396.      {
  2397.        if ( !DupXref(idx,i) )
  2398.        {
  2399.          if ( first )
  2400.          {
  2401.        first = FALSE;
  2402.            sprintf(msgbuf,"\\Xref {\\See {%s}}\n",
  2403.                Entry[i].item->fields[CROSS_REF]);
  2404.        PutString( msgbuf, xdxfile );
  2405.          } /* if */
  2406.          else
  2407.      {
  2408.            sprintf(msgbuf,"\\Morexref {\\See {%s}}\n",
  2409.                Entry[i].item->fields[CROSS_REF]);
  2410.        PutString( msgbuf, xdxfile );
  2411.          } /* else */
  2412.        } /* if - dupXref */
  2413.      } /* if - level */
  2414.    } /* for */
  2415.  
  2416.  
  2417.    /* We need to sort a subset of the entries base on page order,
  2418.       viz, entries with LEVEL5 */
  2419.    SortPageNumber(idx,idx+nxt);
  2420.    
  2421.    n = 0;
  2422.    for ( i=idx; i<idx+nxt; i++)
  2423.    {
  2424.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2425.      switch ( xtype )
  2426.      {
  2427.       case 'x':
  2428.        break;
  2429.       case 'X':
  2430.       default:
  2431.         status = GetPageNum(SubPageOrder[n]);
  2432.         if ( status ) PutPageNum(SubPageOrder[n]);
  2433.     n++;
  2434.     break;
  2435.     } /* switch */
  2436.    } /* for */
  2437.  
  2438.    /* put out cross references again */
  2439.    first  = TRUE;
  2440.    for ( i=idx+1; i<idx+nxt; i++)
  2441.    {
  2442.      level = GetD2(i,idx);
  2443.      xtype = (char) *(Entry[i].item->fields[XREF]);
  2444.      if ( level==5 && ( xtype=='X' || xtype=='x' ) )
  2445.      {
  2446.        if ( !DupXref(idx,i) )
  2447.        {
  2448.          if ( first )
  2449.          {
  2450.           sprintf(msgbuf,"\\Xref {\\See {%s}}\n",
  2451.               Entry[i].item->fields[CROSS_REF]);
  2452.       PutString( msgbuf, xdxfile );
  2453.       first = FALSE;
  2454.          } /* if */
  2455.          else
  2456.      {
  2457.           sprintf(msgbuf,"\\Morexref {\\See {%s}}\n",
  2458.               Entry[i].item->fields[CROSS_REF]);
  2459.       PutString( msgbuf, xdxfile );
  2460.          } /* else */
  2461.        } /* if */
  2462.       } /* if */
  2463.    } /* for */
  2464.  
  2465.    curIndex = idx + nxt;
  2466.    return;
  2467. } /* end - other_proc */
  2468.  
  2469.  
  2470. void TeXPut(idx)
  2471. int  idx;
  2472. {
  2473. char xtype;
  2474.  
  2475.     curLetter = (char) toupper(*(Entry[idx].item->fields[E1]));
  2476.     if ( curLetter != preLetter )
  2477.     {
  2478.          sprintf(msgbuf,"\n\\LETTER %c\n\n",curLetter);
  2479.      PutString( msgbuf, xdxfile );
  2480.          preLetter = curLetter;
  2481.     }
  2482.  
  2483.     xtype = (char) *(Entry[idx].item->fields[XREF]);
  2484.     
  2485.     switch( xtype )
  2486.     {
  2487.        case 'x':
  2488.         xref_proc(idx);
  2489.         break;
  2490.        case 'X':
  2491.         xxref_proc(idx);
  2492.         break;
  2493.        default:
  2494.         other_proc(idx);
  2495.         break;
  2496.     }
  2497.     
  2498.     return;
  2499. } /* end - TeXPut */
  2500.  
  2501.  
  2502.  
  2503. void TeXOut()
  2504. {
  2505.   int  i;
  2506.   
  2507.   printMSG("writing output...");
  2508.   preLetter = 0;
  2509.   for (i=0; i<ndef; i++)
  2510.   {
  2511.      sprintf(msgbuf,"%s\n",define[i]);
  2512.      PutString( msgbuf, xdxfile );
  2513.   } /* for */
  2514.  
  2515.   curIndex = 1;
  2516.   while ( curIndex <= nitems )
  2517.   {
  2518.      TeXPut( curIndex ); 
  2519.   }
  2520.   return;
  2521. } /* end - TexOut */
  2522.  
  2523.  
  2524. /**********************************************************************/
  2525. /* Move Entries                                                  */
  2526. /* Inputs: from, to                                          */
  2527. /* Output: none                                          */
  2528. /**********************************************************************/
  2529. void MoveEntry(from,to)
  2530.  int from,to;
  2531. {
  2532. int k;
  2533.  
  2534.   /* return if both are the same entry */
  2535.   if ( from == to )
  2536.        return;
  2537.  
  2538.   for (k=E1; k<=CROSS_REF; k++)
  2539.   {
  2540.      Entry[to].item->fields[k] = Entry[from].item->fields[k];
  2541.   }
  2542.   
  2543.   return;
  2544. } /* end - MoveEntry */
  2545.  
  2546.  
  2547. /**********************************************************************/
  2548. /* Free Entry                                                  */
  2549. /* Inputs: idx                                              */
  2550. /* Output: none                                          */
  2551. /**********************************************************************/
  2552. void FreeEntry(idx)
  2553.  int idx;
  2554. {
  2555. int j;
  2556.  
  2557.   if ( Entry[idx].item!=NULL )
  2558.   {
  2559.     for ( j=E1; j<=CROSS_REF; j++ )
  2560.     {
  2561.      if ( Entry[idx].item->fields[j]!=NULLPTR )
  2562.       free( Entry[idx].item->fields[j] );
  2563.      Entry[idx].item->fields[j] = NULLPTR;
  2564.     }
  2565.   }
  2566.   
  2567.   return;
  2568.   
  2569. } /* end - FreeEntry */
  2570.  
  2571.  
  2572. /**********************************************************************/
  2573. /* Remove Duplicates Entries                                          */
  2574. /* Inputs: none                                              */
  2575. /* Output: modified nitems                                  */
  2576. /**********************************************************************/
  2577. void RemoveDuplicates()
  2578. {
  2579.   int i,j,cur,level;
  2580.  
  2581.   cur = 1;
  2582.   for ( i=2; i<=nitems; i++ )
  2583.   {
  2584.      if ( DupEntry( i, cur ) )
  2585.      {
  2586.     Entry[i].item->fields[0] = DELPTR;
  2587.      }
  2588.      level = GetD2(i,cur);
  2589.      if ( level!=LEVEL5 )
  2590.       cur = i;
  2591.   }
  2592.  
  2593.   for ( i=1,j=1; i<=nitems; i++ )
  2594.   {
  2595.      if ( Entry[i].item->fields[0]==DELPTR )
  2596.      {
  2597.     FreeEntry(i);
  2598.      }
  2599.      else
  2600.      {
  2601.     MoveEntry(i,j);
  2602.     j++;
  2603.      }
  2604.   }
  2605.   
  2606.   nitems = --j;
  2607.   
  2608.   return;
  2609. } /* end - RemoveDuplicates */
  2610.  
  2611. /* make main() an int so it returns something predictable to the OS */
  2612. int main(argc, argv)
  2613. int  argc;
  2614. char *argv[];
  2615. {
  2616.     
  2617.   if ( argc<2 )
  2618.    {
  2619.       printf("\n\tUsage: index filename\n");
  2620.       exit(0);
  2621.    }
  2622.  
  2623.    printf("\n\tnewindex 1.10    All Rights Reserved.");
  2624.    printf("\n\tCopyright (c) 1989-91 The TeXplorators Corporation.\n");
  2625.       
  2626.    strcpy(ndxname,argv[1]); strcat(ndxname,".ndx");
  2627.    strcpy(tmpname,argv[1]); strcat(tmpname,".@d@");
  2628.    strcpy(xdxname,argv[1]); strcat(xdxname,".xdx");
  2629.    strcpy(idxname,argv[1]); strcat(idxname,".idx");
  2630.  
  2631.    idxfile = FALSE;
  2632.    if ( argc > 2 )
  2633.    {
  2634.       if ( strnicmp(argv[2],"-i",2)==0 )
  2635.        idxfile = TRUE;
  2636.    }
  2637.     
  2638.    if ( ( ndxfile = fopen(ndxname,"r") )==NULL )
  2639.    {
  2640.       printf("File %s not found\r\n",ndxname);
  2641.       beep();
  2642.       exit(0);
  2643.    }
  2644.   
  2645.    if ( ( xxxfile = fopen(tmpname,"w+") )==NULL )
  2646.    {
  2647.      printf("File %s cannot be opened\r\n",tmpname);
  2648.      beep();
  2649.      exit(0);
  2650.    }
  2651.  
  2652.    if ( ( xdxfile = fopen(xdxname,"w") )==NULL )
  2653.    {
  2654.      printf("File %s cannot be opened\r\n",xdxname);
  2655.      beep();
  2656.      exit(0);
  2657.    }
  2658.    
  2659.    InitProc();
  2660.  
  2661.    PreProc();
  2662.  
  2663.    BuildProc();
  2664.    
  2665.    fclose(ndxfile);
  2666.  
  2667.    SortProc();
  2668.    
  2669.    RemoveDuplicates();
  2670.  
  2671.    TeXOut();
  2672.    
  2673.    fclose(xdxfile);
  2674.    fclose(xxxfile);
  2675. #ifdef MICROSOFTC
  2676.    fcloseall();
  2677. #endif
  2678.  
  2679.    unlink(tmpname);
  2680.    FreeMem();
  2681.    
  2682.    printMSG("");
  2683.    printf("\r\n");
  2684.    
  2685.    return(0);
  2686. }
  2687.  
  2688.  
  2689. /* ############################### END OF FILE ########################### */
  2690.